/*      */ package com.iris.egrant.app.utils;
/*      */ 
/*      */ import com.iris.egrant.exception.ServiceException;
/*      */ import java.io.IOException;
/*      */ import java.io.Reader;
/*      */ import java.io.StringReader;
/*      */ import java.math.BigDecimal;
/*      */ import java.sql.Clob;
/*      */ import java.util.ArrayList;
/*      */ import java.util.Arrays;
/*      */ import java.util.Collection;
/*      */ import java.util.HashMap;
/*      */ import java.util.Iterator;
/*      */ import java.util.LinkedList;
/*      */ import java.util.List;
/*      */ import java.util.Locale;
/*      */ import java.util.Map;
/*      */ import java.util.Properties;
/*      */ import java.util.Set;
/*      */ import java.util.StringTokenizer;
/*      */ import java.util.TreeSet;
/*      */ import java.util.regex.Matcher;
/*      */ import java.util.regex.Pattern;
/*      */ import javax.servlet.http.HttpServletRequest;
/*      */ import javax.swing.text.DefaultStyledDocument;
/*      */ import javax.swing.text.rtf.RTFEditorKit;
/*      */ import com.iris.egrant.utils.Assert;
import com.iris.egrant.utils.CollectionUtils;
import com.iris.egrant.utils.ObjectUtils;
import org.apache.commons.lang.StringUtils;
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ public class IrisStringUtils
/*      */ {
/*      */   public static final String PASSWOARD = "[[a-z]|[A-Z]|[0-9]]*";
/*      */   public static final String USERNAME = "[[a-z]|[A-Z]|[0-9]]*";
/*      */   public static final String NUMBER = "[0-9]*";
/*      */   public static final String LETTER = "[[A-Z]|[a-z]]*";
/*      */   public static final String PHONE_NO = "0[0-9]{2,3}-[0-9]{7,8}";
/*      */   public static final String MOBILE_PHONE_NO = "13[0-9][0-9]{8}";
/*      */   public static final String HH_MM_SS = "((0[0-9])||(1[0-9])||(2[0-3])):[0-5][0-9]:[0-5][0-9]";
/*      */   public static final String YEAR_MONTH_DAY_HH_MM_SS = "[0-9]{4}-[0-9]{1,2}-[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2}";
/*      */   private static final String FOLDER_SEPARATOR = "/";
/*      */   private static final String WINDOWS_FOLDER_SEPARATOR = "\\";
/*      */   private static final String TOP_PATH = "..";
/*      */   private static final String CURRENT_PATH = ".";
/*      */   private static final char EXTENSION_SEPARATOR = '.';
/*      */   
/*      */   public static boolean hasLength(String str) {
/*   93 */     return (str != null && str.length() > 0);
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static boolean hasText(String str) {
/*  115 */     if (!hasLength(str)) {
/*  116 */       return false;
/*      */     }
/*  118 */     int strLen = str.length();
/*  119 */     for (int i = 0; i < strLen; i++) {
/*  120 */       if (!Character.isWhitespace(str.charAt(i))) {
/*  121 */         return true;
/*      */       }
/*      */     } 
/*  124 */     return false;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static boolean containsWhitespace(String str) {
/*  136 */     if (!hasLength(str)) {
/*  137 */       return false;
/*      */     }
/*  139 */     int strLen = str.length();
/*  140 */     for (int i = 0; i < strLen; i++) {
/*  141 */       if (Character.isWhitespace(str.charAt(i))) {
/*  142 */         return true;
/*      */       }
/*      */     } 
/*  145 */     return false;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String trimWhitespace(String str) {
/*  157 */     if (!hasLength(str)) {
/*  158 */       return str;
/*      */     }
/*  160 */     StringBuffer buf = new StringBuffer(str);
/*  161 */     while (buf.length() > 0 && Character.isWhitespace(buf.charAt(0))) {
/*  162 */       buf.deleteCharAt(0);
/*      */     }
/*  164 */     while (buf.length() > 0 && Character.isWhitespace(buf.charAt(buf.length() - 1))) {
/*  165 */       buf.deleteCharAt(buf.length() - 1);
/*      */     }
/*  167 */     return buf.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String trimLeadingWhitespace(String str) {
/*  179 */     if (!hasLength(str)) {
/*  180 */       return str;
/*      */     }
/*  182 */     StringBuffer buf = new StringBuffer(str);
/*  183 */     while (buf.length() > 0 && Character.isWhitespace(buf.charAt(0))) {
/*  184 */       buf.deleteCharAt(0);
/*      */     }
/*  186 */     return buf.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String trimTrailingWhitespace(String str) {
/*  198 */     if (!hasLength(str)) {
/*  199 */       return str;
/*      */     }
/*  201 */     StringBuffer buf = new StringBuffer(str);
/*  202 */     while (buf.length() > 0 && Character.isWhitespace(buf.charAt(buf.length() - 1))) {
/*  203 */       buf.deleteCharAt(buf.length() - 1);
/*      */     }
/*  205 */     return buf.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String trimAllWhitespace(String str) {
/*  217 */     if (!hasLength(str)) {
/*  218 */       return str;
/*      */     }
/*  220 */     StringBuffer buf = new StringBuffer(str);
/*  221 */     int index = 0;
/*  222 */     while (buf.length() > index) {
/*  223 */       if (Character.isWhitespace(buf.charAt(index))) {
/*  224 */         buf.deleteCharAt(index); continue;
/*      */       } 
/*  226 */       index++;
/*      */     } 
/*      */     
/*  229 */     return buf.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static boolean startsWithIgnoreCase(String str, String prefix) {
/*  242 */     if (str == null || prefix == null) {
/*  243 */       return false;
/*      */     }
/*  245 */     if (str.startsWith(prefix)) {
/*  246 */       return true;
/*      */     }
/*  248 */     if (str.length() < prefix.length()) {
/*  249 */       return false;
/*      */     }
/*  251 */     String lcStr = str.substring(0, prefix.length()).toLowerCase();
/*  252 */     String lcPrefix = prefix.toLowerCase();
/*  253 */     return lcStr.equals(lcPrefix);
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static boolean endsWithIgnoreCase(String str, String suffix) {
/*  266 */     if (str == null || suffix == null) {
/*  267 */       return false;
/*      */     }
/*  269 */     if (str.endsWith(suffix)) {
/*  270 */       return true;
/*      */     }
/*  272 */     if (str.length() < suffix.length()) {
/*  273 */       return false;
/*      */     }
/*      */     
/*  276 */     String lcStr = str.substring(str.length() - suffix.length()).toLowerCase();
/*  277 */     String lcSuffix = suffix.toLowerCase();
/*  278 */     return lcStr.equals(lcSuffix);
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static int countOccurrencesOf(String str, String sub) {
/*  290 */     if (str == null || sub == null || str.length() == 0 || sub.length() == 0) {
/*  291 */       return 0;
/*      */     }
/*  293 */     int count = 0, pos = 0, idx = 0;
/*  294 */     while ((idx = str.indexOf(sub, pos)) != -1) {
/*  295 */       count++;
/*  296 */       pos = idx + sub.length();
/*      */     } 
/*  298 */     return count;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String replace(String inString, String oldPattern, String newPattern) {
/*  313 */     if (inString == null) {
/*  314 */       return null;
/*      */     }
/*  316 */     if (oldPattern == null || newPattern == null) {
/*  317 */       return inString;
/*      */     }
/*      */     
/*  320 */     StringBuffer sbuf = new StringBuffer();
/*      */     
/*  322 */     int pos = 0;
/*  323 */     int index = inString.indexOf(oldPattern);
/*      */     
/*  325 */     int patLen = oldPattern.length();
/*  326 */     while (index >= 0) {
/*  327 */       sbuf.append(inString.substring(pos, index));
/*  328 */       sbuf.append(newPattern);
/*  329 */       pos = index + patLen;
/*  330 */       index = inString.indexOf(oldPattern, pos);
/*      */     } 
/*  332 */     sbuf.append(inString.substring(pos));
/*      */ 
/*      */     
/*  335 */     return sbuf.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String delete(String inString, String pattern) {
/*  345 */     return replace(inString, pattern, "");
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String deleteAny(String inString, String charsToDelete) {
/*  355 */     if (inString == null || charsToDelete == null) {
/*  356 */       return inString;
/*      */     }
/*  358 */     StringBuffer out = new StringBuffer();
/*  359 */     for (int i = 0; i < inString.length(); i++) {
/*  360 */       char c = inString.charAt(i);
/*  361 */       if (charsToDelete.indexOf(c) == -1) {
/*  362 */         out.append(c);
/*      */       }
/*      */     } 
/*  365 */     return out.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String quote(String str) {
/*  380 */     return (str != null) ? ("'" + str + "'") : null;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static Object quoteIfString(Object obj) {
/*  391 */     return (obj instanceof String) ? quote((String)obj) : obj;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String unqualify(String qualifiedName) {
/*  401 */     return unqualify(qualifiedName, '.');
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String unqualify(String qualifiedName, char separator) {
/*  414 */     return qualifiedName.substring(qualifiedName.lastIndexOf(separator) + 1);
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String capitalize(String str) {
/*  426 */     return changeFirstCharacterCase(str, true);
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String uncapitalize(String str) {
/*  438 */     return changeFirstCharacterCase(str, false);
/*      */   }
/*      */   
/*      */   private static String changeFirstCharacterCase(String str, boolean capitalize) {
/*  442 */     if (str == null || str.length() == 0) {
/*  443 */       return str;
/*      */     }
/*  445 */     StringBuffer buf = new StringBuffer(str.length());
/*  446 */     if (capitalize) {
/*  447 */       buf.append(Character.toUpperCase(str.charAt(0)));
/*      */     } else {
/*  449 */       buf.append(Character.toLowerCase(str.charAt(0)));
/*      */     } 
/*  451 */     buf.append(str.substring(1));
/*  452 */     return buf.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String getFilename(String path) {
/*  463 */     if (path == null) {
/*  464 */       return null;
/*      */     }
/*  466 */     int separatorIndex = path.lastIndexOf("/");
/*  467 */     return (separatorIndex != -1) ? path.substring(separatorIndex + 1) : path;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String getFilenameExtension(String path) {
/*  478 */     if (path == null) {
/*  479 */       return null;
/*      */     }
/*  481 */     int sepIndex = path.lastIndexOf('.');
/*  482 */     return (sepIndex != -1) ? path.substring(sepIndex + 1) : null;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String stripFilenameExtension(String path) {
/*  493 */     if (path == null) {
/*  494 */       return null;
/*      */     }
/*  496 */     int sepIndex = path.lastIndexOf('.');
/*  497 */     return (sepIndex != -1) ? path.substring(0, sepIndex) : path;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String applyRelativePath(String path, String relativePath) {
/*  510 */     int separatorIndex = path.lastIndexOf("/");
/*  511 */     if (separatorIndex != -1) {
/*  512 */       String newPath = path.substring(0, separatorIndex);
/*  513 */       if (!relativePath.startsWith("/")) {
/*  514 */         newPath = newPath + "/";
/*      */       }
/*  516 */       return newPath + relativePath;
/*      */     } 
/*  518 */     return relativePath;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String cleanPath(String path) {
/*  534 */     String pathToUse = replace(path, "\\", "/");
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */     
/*  540 */     int prefixIndex = pathToUse.indexOf(":");
/*  541 */     String prefix = "";
/*  542 */     if (prefixIndex != -1) {
/*  543 */       prefix = pathToUse.substring(0, prefixIndex + 1);
/*  544 */       pathToUse = pathToUse.substring(prefixIndex + 1);
/*      */     } 
/*      */     
/*  547 */     String[] pathArray = delimitedListToStringArray(pathToUse, "/");
/*  548 */     List<String> pathElements = new LinkedList();
/*  549 */     int tops = 0;
/*      */     int i;
/*  551 */     for (i = pathArray.length - 1; i >= 0; i--) {
/*  552 */       if (!".".equals(pathArray[i]))
/*      */       {
/*  554 */         if ("..".equals(pathArray[i])) {
/*      */           
/*  556 */           tops++;
/*      */         }
/*  558 */         else if (tops > 0) {
/*      */           
/*  560 */           tops--;
/*      */         } else {
/*      */           
/*  563 */           pathElements.add(0, pathArray[i]);
/*      */         } 
/*      */       }
/*      */     } 
/*      */ 
/*      */     
/*  569 */     for (i = 0; i < tops; i++) {
/*  570 */       pathElements.add(0, "..");
/*      */     }
/*      */     
/*  573 */     return prefix + collectionToDelimitedString(pathElements, "/");
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static boolean pathEquals(String path1, String path2) {
/*  586 */     return cleanPath(path1).equals(cleanPath(path2));
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static Locale parseLocaleString(String localeString) {
/*  599 */     String[] parts = tokenizeToStringArray(localeString, "_ ", false, false);
/*  600 */     String language = (parts.length > 0) ? parts[0] : "";
/*  601 */     String country = (parts.length > 1) ? parts[1] : "";
/*  602 */     String variant = (parts.length > 2) ? parts[2] : "";
/*  603 */     return (language.length() > 0) ? new Locale(language, country, variant) : null;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String[] addStringToArray(String[] array, String str) {
/*  621 */     if (ObjectUtils.isEmpty((Object[])array)) {
/*  622 */       return new String[] { str };
/*      */     }
/*  624 */     String[] newArr = new String[array.length + 1];
/*  625 */     System.arraycopy(array, 0, newArr, 0, array.length);
/*  626 */     newArr[array.length] = str;
/*  627 */     return newArr;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String[] concatenateStringArrays(String[] array1, String[] array2) {
/*  642 */     if (ObjectUtils.isEmpty((Object[])array1)) {
/*  643 */       return array2;
/*      */     }
/*  645 */     if (ObjectUtils.isEmpty((Object[])array2)) {
/*  646 */       return array1;
/*      */     }
/*  648 */     String[] newArr = new String[array1.length + array2.length];
/*  649 */     System.arraycopy(array1, 0, newArr, 0, array1.length);
/*  650 */     System.arraycopy(array2, 0, newArr, array1.length, array2.length);
/*  651 */     return newArr;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String[] mergeStringArrays(String[] array1, String[] array2) {
/*  667 */     if (ObjectUtils.isEmpty((Object[])array1)) {
/*  668 */       return array2;
/*      */     }
/*  670 */     if (ObjectUtils.isEmpty((Object[])array2)) {
/*  671 */       return array1;
/*      */     }
/*  673 */     List<String> result = new ArrayList();
/*  674 */     result.addAll(Arrays.asList(array1));
/*  675 */     for (String element : array2) {
/*  676 */       String str = element;
/*  677 */       if (!result.contains(str)) {
/*  678 */         result.add(str);
/*      */       }
/*      */     } 
/*  681 */     return toStringArray(result);
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String[] sortStringArray(String[] array) {
/*  692 */     if (ObjectUtils.isEmpty((Object[])array)) {
/*  693 */       return new String[0];
/*      */     }
/*  695 */     Arrays.sort((Object[])array);
/*  696 */     return array;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String[] toStringArray(Collection collection) {
/*  707 */     if (collection == null) {
/*  708 */       return null;
/*      */     }
/*  710 */     return (String[])collection.toArray((Object[])new String[collection.size()]);
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String[] removeDuplicateStrings(String[] array) {
/*  721 */     if (ObjectUtils.isEmpty((Object[])array)) {
/*  722 */       return array;
/*      */     }
/*  724 */     Set<String> set = new TreeSet();
/*  725 */     for (String element : array) {
/*  726 */       set.add(element);
/*      */     }
/*  728 */     return toStringArray(set);
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String[] splitFirst(String toSplit, String delimiter) {
/*  743 */     if (!hasLength(toSplit) || !hasLength(delimiter)) {
/*  744 */       return null;
/*      */     }
/*  746 */     int offset = toSplit.indexOf(delimiter);
/*  747 */     if (offset < 0) {
/*  748 */       return null;
/*      */     }
/*  750 */     String beforeDelimiter = toSplit.substring(0, offset);
/*  751 */     String afterDelimiter = toSplit.substring(offset + delimiter.length());
/*  752 */     return new String[] { beforeDelimiter, afterDelimiter };
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static Properties splitArrayElementsIntoProperties(String[] array, String delimiter) {
/*  770 */     return splitArrayElementsIntoProperties(array, delimiter, null);
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static Properties splitArrayElementsIntoProperties(String[] array, String delimiter, String charsToDelete) {
/*  792 */     if (ObjectUtils.isEmpty((Object[])array)) {
/*  793 */       return null;
/*      */     }
/*  795 */     Properties result = new Properties();
/*  796 */     for (String element2 : array) {
/*  797 */       String element = element2;
/*  798 */       if (charsToDelete != null) {
/*  799 */         element = deleteAny(element2, charsToDelete);
/*      */       }
/*  801 */       String[] splittedElement = splitFirst(element, delimiter);
/*  802 */       if (splittedElement != null)
/*      */       {
/*      */         
/*  805 */         result.setProperty(splittedElement[0].trim(), splittedElement[1].trim()); } 
/*      */     } 
/*  807 */     return result;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String[] tokenizeToStringArray(String str, String delimiters) {
/*  828 */     return tokenizeToStringArray(str, delimiters, true, true);
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String[] tokenizeToStringArray(String str, String delimiters, boolean trimTokens, boolean ignoreEmptyTokens) {
/*  856 */     StringTokenizer st = new StringTokenizer(str, delimiters);
/*  857 */     List<String> tokens = new ArrayList();
/*  858 */     while (st.hasMoreTokens()) {
/*  859 */       String token = st.nextToken();
/*  860 */       if (trimTokens) {
/*  861 */         token = token.trim();
/*      */       }
/*  863 */       if (!ignoreEmptyTokens || token.length() > 0) {
/*  864 */         tokens.add(token);
/*      */       }
/*      */     } 
/*  867 */     return toStringArray(tokens);
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String[] delimitedListToStringArray(String str, String delimiter) {
/*  886 */     if (str == null) {
/*  887 */       return new String[0];
/*      */     }
/*  889 */     if (delimiter == null) {
/*  890 */       return new String[] { str };
/*      */     }
/*  892 */     List<String> result = new ArrayList();
/*  893 */     if ("".equals(delimiter)) {
/*  894 */       for (int i = 0; i < str.length(); i++) {
/*  895 */         result.add(str.substring(i, i + 1));
/*      */       }
/*      */     } else {
/*  898 */       int pos = 0;
/*  899 */       int delPos = 0;
/*  900 */       while ((delPos = str.indexOf(delimiter, pos)) != -1) {
/*  901 */         result.add(str.substring(pos, delPos));
/*  902 */         pos = delPos + delimiter.length();
/*      */       } 
/*  904 */       if (str.length() > 0 && pos <= str.length())
/*      */       {
/*  906 */         result.add(str.substring(pos));
/*      */       }
/*      */     } 
/*  909 */     return toStringArray(result);
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String[] commaDelimitedListToStringArray(String str) {
/*  920 */     return delimitedListToStringArray(str, ",");
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static Set commaDelimitedListToSet(String str) {
/*  931 */     Set<String> set = new TreeSet();
/*  932 */     String[] tokens = commaDelimitedListToStringArray(str);
/*  933 */     for (String token : tokens) {
/*  934 */       set.add(token);
/*      */     }
/*  936 */     return set;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String collectionToDelimitedString(Collection coll, String delim, String prefix, String suffix) {
/*  953 */     if (CollectionUtils.isEmpty(coll)) {
/*  954 */       return "";
/*      */     }
/*  956 */     StringBuffer sb = new StringBuffer();
/*  957 */     Iterator it = coll.iterator();
/*  958 */     while (it.hasNext()) {
/*  959 */       sb.append(prefix).append(it.next()).append(suffix);
/*  960 */       if (it.hasNext()) {
/*  961 */         sb.append(delim);
/*      */       }
/*      */     } 
/*  964 */     return sb.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String collectionToDelimitedString(Collection coll, String delim) {
/*  977 */     return collectionToDelimitedString(coll, delim, "", "");
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String collectionToCommaDelimitedString(Collection coll) {
/*  988 */     return collectionToDelimitedString(coll, ",");
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String arrayToDelimitedString(Object[] arr, String delim) {
/* 1001 */     if (ObjectUtils.isEmpty(arr)) {
/* 1002 */       return "";
/*      */     }
/* 1004 */     StringBuffer sb = new StringBuffer();
/* 1005 */     for (int i = 0; i < arr.length; i++) {
/* 1006 */       if (i > 0) {
/* 1007 */         sb.append(delim);
/*      */       }
/* 1009 */       sb.append(arr[i]);
/*      */     } 
/* 1011 */     return sb.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String arrayToCommaDelimitedString(Object[] arr) {
/* 1022 */     return arrayToDelimitedString(arr, ",");
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static boolean isDefinedPattern(String str, String pattern) {
/* 1034 */     Assert.notNull(str);
/* 1035 */     Assert.notNull(pattern);
/*      */     
/* 1037 */     Pattern p = Pattern.compile(pattern);
/* 1038 */     Matcher m = p.matcher(str);
/* 1039 */     return m.matches();
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String replaceByPattern(String str1, String pattern, String str2) {
/* 1053 */     Assert.notNull(str1);
/* 1054 */     Assert.notNull(pattern);
/* 1055 */     Assert.notNull(str2);
/*      */     
/* 1057 */     Pattern p = Pattern.compile(pattern);
/* 1058 */     Matcher m = p.matcher(str1);
/* 1059 */     return m.replaceAll(str2);
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String[] splitByPattern(String str, String pattern) {
/* 1073 */     Assert.notNull(pattern);
/*      */     
/* 1075 */     if (hasLength(str)) {
/* 1076 */       Pattern p = Pattern.compile(pattern);
/* 1077 */       return p.split(str);
/*      */     } 
/* 1079 */     return null;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static boolean isNullOrBlank(String str) {
/* 1089 */     if (str == null)
/* 1090 */       return true; 
/* 1091 */     if (str.trim().equals("")) {
/* 1092 */       return true;
/*      */     }
/* 1094 */     return false;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String parseToString(String str) {
/* 1105 */     if (str == null) {
/* 1106 */       return null;
/*      */     }
/* 1108 */     return str.replaceAll("\r|\n|\t", " ");
/*      */   }
/*      */ 
/*      */   
/*      */   public static String getText(String info, Object... arg) {
/* 1113 */     if (arg != null && arg.length > 0) {
/* 1114 */       for (int i = 0; i < arg.length; i++) {
/* 1115 */         String val = (arg[i] == null) ? "" : arg[i].toString();
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */         
/* 1121 */         info = info.replaceAll("(\\{" + i + "\\})", filterDollarStr(val));
/*      */       } 
/*      */     }
/* 1124 */     return info;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String filterDollarStr(String str) {
/* 1136 */     StringBuffer sReturn = new StringBuffer("");
/* 1137 */     if (str.indexOf('$', 0) > -1) {
/* 1138 */       while (str.length() > 0) {
/* 1139 */         if (str.indexOf('$', 0) > -1) {
/* 1140 */           sReturn.append(str.subSequence(0, str.indexOf('$', 0)));
/* 1141 */           sReturn.append("\\$");
/* 1142 */           str = str.substring(str.indexOf('$', 0) + 1, str.length()); continue;
/*      */         } 
/* 1144 */         sReturn.append(str);
/* 1145 */         str = "";
/*      */       } 
/*      */     } else {
/*      */       
/* 1149 */       sReturn = new StringBuffer(str);
/*      */     } 
/* 1151 */     return sReturn.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static List<Integer> getSplitInt(String strs) throws ServiceException {
/* 1162 */     List<Integer> list = new ArrayList<Integer>();
/* 1163 */     if (strs == null) {
/* 1164 */       return list;
/*      */     }
/* 1166 */     String[] strGroup = strs.split(",");
/* 1167 */     for (String str : strGroup) {
/*      */       try {
/* 1169 */         Integer value = new Integer(str);
/* 1170 */         list.add(value);
/* 1171 */       } catch (Exception e) {
/* 1172 */         throw new ServiceException("类型转换失败，字符串转换成Integer");
/*      */       } 
/*      */     } 
/*      */     
/* 1176 */     return list;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static List<Long> getSplitLong(String strs) throws ServiceException {
/* 1188 */     List<Long> list = new ArrayList<Long>();
/* 1189 */     if (strs == null) {
/* 1190 */       return list;
/*      */     }
/* 1192 */     String[] strGroup = strs.split(",");
/* 1193 */     for (String str : strGroup) {
/*      */       try {
/* 1195 */         Long value = new Long(str);
/* 1196 */         list.add(value);
/* 1197 */       } catch (Exception e) {
/* 1198 */         throw new ServiceException("类型转换失败，字符串转换成Long");
/*      */       } 
/*      */     } 
/*      */     
/* 1202 */     return list;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static List<String> getSplitStr(String strs) {
/* 1213 */     List<String> list = new ArrayList<String>();
/* 1214 */     StringBuffer strTemp = new StringBuffer();
/* 1215 */     if (strs == null) {
/* 1216 */       return list;
/*      */     }
/* 1218 */     String[] strGroup = strs.split(",");
/* 1219 */     for (int i = 0; i < strGroup.length; i++) {
/* 1220 */       if (i != 0 && i % 1000 == 0) {
/* 1221 */         list.add(strTemp.toString().substring(0, strTemp.toString().length() - 1));
/* 1222 */         strTemp = new StringBuffer();
/* 1223 */         strTemp.append(strGroup[i]).append(",");
/*      */       } else {
/* 1225 */         strTemp.append(strGroup[i]).append(",");
/*      */       } 
/*      */     } 
/* 1228 */     list.add(strTemp.toString().substring(0, strTemp.toString().length() - 1));
/* 1229 */     return list;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String[] split(CharSequence input, String delimiterPattern, int limit) {
/* 1247 */     int index = 0;
/* 1248 */     boolean matchLimited = (limit > 0);
/* 1249 */     ArrayList<String> matchList = new ArrayList();
/* 1250 */     Pattern p = Pattern.compile(delimiterPattern);
/* 1251 */     Matcher m = p.matcher(input);
/*      */ 
/*      */     
/* 1254 */     while (m.find()) {
/* 1255 */       if (!matchLimited || matchList.size() < limit - 1) {
/* 1256 */         String match = input.subSequence(index, m.start()).toString();
/* 1257 */         matchList.add(match);
/* 1258 */         index = m.end(); continue;
/* 1259 */       }  if (matchList.size() == limit - 1) {
/* 1260 */         String match = input.subSequence(index, input.length()).toString();
/* 1261 */         matchList.add(match);
/* 1262 */         index = m.end();
/*      */       } 
/*      */     } 
/*      */ 
/*      */     
/* 1267 */     if (index == 0) {
/* 1268 */       return new String[] { input.toString() };
/*      */     }
/*      */ 
/*      */     
/* 1272 */     if (!matchLimited || matchList.size() < limit) {
/* 1273 */       matchList.add(input.subSequence(index, input.length()).toString());
/*      */     }
/*      */ 
/*      */     
/* 1277 */     int resultSize = matchList.size();
/*      */ 
/*      */ 
/*      */ 
/*      */     
/* 1282 */     String[] result = new String[resultSize];
/* 1283 */     return (String[])matchList.subList(0, resultSize).toArray((Object[])result);
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static boolean isIncludeSubString(String str, String subString) {
/* 1296 */     boolean result = false;
/* 1297 */     if (str == null || subString == null) {
/* 1298 */       return false;
/*      */     }
/* 1300 */     int strLength = str.length();
/* 1301 */     int subStrLength = subString.length();
/* 1302 */     String tmpStr = null;
/* 1303 */     for (int i = 0; i < strLength; i++) {
/* 1304 */       if (strLength - i < subStrLength) {
/* 1305 */         return false;
/*      */       }
/* 1307 */       tmpStr = str.substring(i, subStrLength + i);
/* 1308 */       if (tmpStr.endsWith(subString)) {
/* 1309 */         return true;
/*      */       }
/*      */     } 
/* 1312 */     return result;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String[] split(CharSequence input, String delimiterPattern) {
/* 1327 */     return split(input, delimiterPattern, 0);
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String[] splitSameLegthArray(String str, int length) {
/* 1338 */     if (length <= 0 || str == null) {
/* 1339 */       return null;
/*      */     }
/* 1341 */     String[] strArr = new String[str.length() / length + 1];
/*      */     
/* 1343 */     char[] cStr = str.toCharArray();
/* 1344 */     StringBuffer buf = new StringBuffer();
/* 1345 */     int count = 0;
/* 1346 */     int leg = 0;
/* 1347 */     for (char s : cStr) {
/* 1348 */       if (count != length) {
/* 1349 */         buf.append(String.valueOf(s));
/* 1350 */         count++;
/*      */       } else {
/* 1352 */         strArr[leg++] = buf.toString();
/* 1353 */         buf.delete(0, buf.length());
/* 1354 */         buf.append(String.valueOf(s));
/* 1355 */         count = 1;
/*      */       } 
/*      */     } 
/* 1358 */     if (buf.length() != 0) {
/* 1359 */       strArr[leg++] = buf.toString();
/*      */     }
/* 1361 */     return strArr;
/*      */   }
/*      */   
/*      */   public static Properties toProperties(String str) {
/* 1365 */     return toProperties(str, ",");
/*      */   }
/*      */   
/*      */   public static Properties toProperties(String str, String split) {
/* 1369 */     Properties props = new Properties();
/* 1370 */     if (!hasLength(str)) {
/* 1371 */       return props;
/*      */     }
/* 1373 */     String[] lines = str.split(split);
/* 1374 */     for (String line : lines) {
/* 1375 */       if (line == null) {
/* 1376 */         return null;
/*      */       }
/* 1378 */       line = trimLeadingWhitespace(line);
/* 1379 */       if (line.length() > 0) {
/* 1380 */         char firstChar = line.charAt(0);
/* 1381 */         if (firstChar != '#' && firstChar != '!') {
/* 1382 */           int separatorIndex = line.indexOf("=");
/* 1383 */           if (separatorIndex == -1) {
/* 1384 */             separatorIndex = line.indexOf(":");
/*      */           }
/* 1386 */           String key = (separatorIndex != -1) ? line.substring(0, separatorIndex) : line;
/* 1387 */           String value = (separatorIndex != -1) ? line.substring(separatorIndex + 1) : "";
/* 1388 */           key = trimTrailingWhitespace(key);
/* 1389 */           value = trimLeadingWhitespace(value);
/* 1390 */           props.put(key, value);
/*      */         } 
/*      */       } 
/*      */     } 
/* 1394 */     return props;
/*      */   }
/*      */   
/*      */   public static String toString(Object obj) {
/* 1398 */     return (obj == null) ? "" : obj.toString();
/*      */   }
/*      */ 
/*      */   
/* 1402 */   static String[] partern = new String[] { "元", "拾", "百", "千", "万", "拾", "百", "千", "亿", "拾", "百", "千", "兆" };
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String replaceStrs(String strSource, String strFrom, String strTo) {
/* 1416 */     if (strFrom == null || strFrom.equals("")) {
/* 1417 */       return strSource;
/*      */     }
/* 1419 */     String strDest = "";
/*      */     
/* 1421 */     int intFromLen = strFrom.length();
/*      */     
/*      */     int intPos;
/* 1424 */     while ((intPos = strSource.indexOf(strFrom)) != -1) {
/*      */       
/* 1426 */       strDest = strDest + strSource.substring(0, intPos);
/*      */       
/* 1428 */       strDest = strDest + strTo;
/*      */       
/* 1430 */       strSource = strSource.substring(intPos + intFromLen);
/*      */     } 
/*      */     
/* 1433 */     strDest = strDest + strSource;
/*      */     
/* 1435 */     return strDest;
/*      */   }
/*      */   
/*      */   public static String filterNull(Object obj) {
/* 1439 */     if (obj == null) {
/* 1440 */       return "";
/*      */     }
/*      */     
/* 1443 */     return String.valueOf(obj);
/*      */   }
/*      */   
/*      */   public static String replaceRN(String strSource) {
/* 1447 */     char c1 = '\n';
/* 1448 */     char c2 = '\r';
/* 1449 */     String result = replace(strSource, String.valueOf(c2) + String.valueOf(c1), "&#13;&#10;");
/* 1450 */     return result;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String padLeft(String s, int len, char pad_ch) {
/* 1488 */     if (s.length() >= len) {
/* 1489 */       return s;
/*      */     }
/* 1491 */     StringBuilder sb = new StringBuilder();
/* 1492 */     int n = len - s.length();
/* 1493 */     for (int i = 0; i < n; i++) {
/* 1494 */       sb.append(pad_ch);
/*      */     }
/* 1496 */     sb.append(s);
/* 1497 */     return sb.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String padRight(String s, int len, char pad_ch) {
/* 1510 */     if (s.length() >= len) {
/* 1511 */       return s;
/*      */     }
/* 1513 */     StringBuilder sb = new StringBuilder();
/* 1514 */     int n = len - s.length();
/* 1515 */     sb.append(s);
/* 1516 */     for (int i = 0; i < n; i++) {
/* 1517 */       sb.append(pad_ch);
/*      */     }
/* 1519 */     return sb.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String maskLeft(String s, int len, char mask_ch) {
/* 1527 */     if (len <= 0) {
/* 1528 */       return s;
/*      */     }
/* 1530 */     len = Math.min(len, s.length());
/* 1531 */     StringBuilder sb = new StringBuilder();
/* 1532 */     for (int i = 0; i < len; i++) {
/* 1533 */       sb.append(mask_ch);
/*      */     }
/* 1535 */     sb.append(s.substring(len));
/* 1536 */     return sb.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String maskRight(String s, int len, char mask_ch) {
/* 1543 */     if (len <= 0) {
/* 1544 */       return s;
/*      */     }
/* 1546 */     len = Math.min(len, s.length());
/* 1547 */     StringBuilder sb = new StringBuilder();
/* 1548 */     sb.append(s.substring(0, s.length() - len));
/* 1549 */     for (int i = 0; i < len; i++) {
/* 1550 */       sb.append(mask_ch);
/*      */     }
/* 1552 */     return sb.toString();
/*      */   }
/*      */ 
/*      */   
/*      */   public static String switchMoneyChinese(BigDecimal bg) throws Exception {
/* 1557 */     if (bg == null) {
/* 1558 */       throw new Exception("输入金额不正确！");
/*      */     }
/*      */ 
/*      */     
/* 1562 */     String amt = bg.toString();
/*      */     
/* 1564 */     if ("0".equalsIgnoreCase(amt) || "0.0".equalsIgnoreCase(amt) || "0.00".equalsIgnoreCase(amt)) {
/* 1565 */       return "零元整";
/*      */     }
/*      */ 
/*      */     
/* 1569 */     int local = amt.indexOf(".");
/* 1570 */     if (local != -1 && amt.substring(local + 1).length() > 2) {
/* 1571 */       throw new Exception("输入金额不能操过两位小数！");
/*      */     }
/*      */ 
/*      */     
/* 1575 */     String[] temp = switchIntAndDig(amt);
/*      */     
/* 1577 */     StringBuffer sb = new StringBuffer();
/* 1578 */     sb.append(generateIntegerChinese(temp[0]));
/* 1579 */     sb.append(generateDigitalChinese(temp[1]));
/*      */     
/* 1581 */     return sb.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */   
/*      */   private static String generateIntegerChinese(String digital) throws Exception {
/* 1587 */     if (digital == null || digital.length() > 13) {
/* 1588 */       throw new Exception("输入的整数位数不正确或者金额过于庞大！");
/*      */     }
/*      */     
/* 1591 */     StringBuffer sb = new StringBuffer();
/* 1592 */     for (int i = 0; i < digital.length(); i++) {
/* 1593 */       char ch = digital.charAt(i);
/* 1594 */       if (digital.length() - i == 5 && ch == '0') {
/* 1595 */         sb.append("万");
/*      */       }
/*      */       
/* 1598 */       if (digital.length() - i == 9 && ch == '0') {
/* 1599 */         sb.append("亿");
/*      */       }
/*      */       
/* 1602 */       if (i == digital.length() - 1 && ch == '0') {
/* 1603 */         sb.append("元");
/*      */       }
/*      */       
/* 1606 */       if (ch != '0') {
/*      */ 
/*      */         
/* 1609 */         sb.append(swtichtoChinese(ch));
/* 1610 */         sb.append(partern[digital.length() - 1 - i]);
/*      */       } 
/* 1612 */     }  return sb.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */   
/*      */   private static String generateDigitalChinese(String digital) throws Exception {
/* 1618 */     if (digital == null || digital.length() > 2) {
/* 1619 */       throw new Exception("输入的小数位数不正确，请在两位之内！");
/*      */     }
/*      */ 
/*      */     
/* 1623 */     if ("00".equals(digital) || "0".equals(digital)) {
/* 1624 */       return "整";
/*      */     }
/*      */     
/* 1627 */     StringBuffer sb = new StringBuffer();
/* 1628 */     for (int i = 0; i < digital.length(); i++) {
/* 1629 */       char ch = digital.charAt(i);
/* 1630 */       if (ch != '0') {
/*      */ 
/*      */         
/* 1633 */         sb.append(swtichtoChinese(ch));
/* 1634 */         if (i == 0) {
/* 1635 */           sb.append("角");
/*      */         } else {
/* 1637 */           sb.append("分");
/*      */         } 
/*      */       } 
/*      */     } 
/* 1641 */     return sb.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */   
/*      */   private static String[] switchIntAndDig(String money) throws Exception {
/* 1647 */     String[] rslt = { "", "" };
/*      */ 
/*      */     
/*      */     try {
/* 1651 */       new BigDecimal(money);
/* 1652 */     } catch (Exception e) {
/* 1653 */       throw new Exception("输入参数不正确！");
/*      */     } 
/*      */ 
/*      */     
/* 1657 */     int local = money.indexOf(".");
/* 1658 */     if (local == -1) {
/* 1659 */       rslt[0] = money;
/* 1660 */       rslt[1] = "0";
/*      */     } else {
/* 1662 */       rslt[0] = money.substring(0, local);
/* 1663 */       rslt[1] = money.substring(local + 1);
/*      */     } 
/*      */     
/* 1666 */     return rslt;
/*      */   }
/*      */ 
/*      */   
/*      */   private static String swtichtoChinese(char ch) throws Exception {
/* 1671 */     switch (ch) {
/*      */       case '0':
/* 1673 */         return "零";
/*      */       case '1':
/* 1675 */         return "壹";
/*      */       case '2':
/* 1677 */         return "贰";
/*      */       case '3':
/* 1679 */         return "叁";
/*      */       case '4':
/* 1681 */         return "肆";
/*      */       case '5':
/* 1683 */         return "伍";
/*      */       case '6':
/* 1685 */         return "陆";
/*      */       case '7':
/* 1687 */         return "柒";
/*      */       case '8':
/* 1689 */         return "捌";
/*      */       case '9':
/* 1691 */         return "玖";
/*      */     } 
/* 1693 */     throw new Exception("输入字符不正确");
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static void genChineseMoneyTable(HttpServletRequest request, BigDecimal bg, String flag) throws Exception {
/* 1707 */     StringBuilder sb = new StringBuilder("");
/*      */     
/* 1709 */     String amt = bg.toString();
/* 1710 */     String[] temp = switchIntAndDig(amt);
/* 1711 */     String arr = padLeft(temp[0], 8, '0');
/* 1712 */     String str = "";
/* 1713 */     for (int i = 0; i < arr.length(); i++) {
/* 1714 */       str = arr.substring(i, i + 1);
/* 1715 */       if (i == 0) {
/* 1716 */         if ("0".equals(str)) {
/* 1717 */           request.setAttribute(flag + "QW", "&nbsp;零");
/*      */         } else {
/* 1719 */           request.setAttribute(flag + "QW", "&nbsp;" + swtichtoChinese(str.charAt(0)));
/*      */         } 
/* 1721 */       } else if (i == 1) {
/* 1722 */         if ("0".equals(str)) {
/* 1723 */           request.setAttribute(flag + "BW", "&nbsp;零");
/*      */         } else {
/* 1725 */           request.setAttribute(flag + "BW", "&nbsp;" + swtichtoChinese(str.charAt(0)));
/*      */         } 
/* 1727 */       } else if (i == 2) {
/* 1728 */         if ("0".equals(str)) {
/* 1729 */           request.setAttribute(flag + "SW", "&nbsp;零");
/*      */         } else {
/* 1731 */           request.setAttribute(flag + "SW", "&nbsp;" + swtichtoChinese(str.charAt(0)));
/*      */         } 
/* 1733 */       } else if (i == 3) {
/* 1734 */         if ("0".equals(str)) {
/* 1735 */           request.setAttribute(flag + "W", "&nbsp;零");
/*      */         } else {
/* 1737 */           request.setAttribute(flag + "W", "&nbsp;" + swtichtoChinese(str.charAt(0)));
/*      */         } 
/* 1739 */       } else if (i == 4) {
/* 1740 */         if ("0".equals(str)) {
/* 1741 */           request.setAttribute(flag + "Q", "零&nbsp;");
/*      */         } else {
/* 1743 */           request.setAttribute(flag + "Q", "&nbsp;" + swtichtoChinese(str.charAt(0)));
/*      */         } 
/* 1745 */       } else if (i == 5) {
/* 1746 */         if ("0".equals(str)) {
/* 1747 */           request.setAttribute(flag + "B", "零&nbsp;");
/*      */         } else {
/* 1749 */           request.setAttribute(flag + "B", "&nbsp;" + swtichtoChinese(str.charAt(0)));
/*      */         } 
/* 1751 */       } else if (i == 6) {
/* 1752 */         if ("0".equals(str)) {
/* 1753 */           request.setAttribute(flag + "S", "&nbsp;零");
/*      */         } else {
/* 1755 */           request.setAttribute(flag + "S", "&nbsp;" + swtichtoChinese(str.charAt(0)));
/*      */         } 
/* 1757 */       } else if (i == 7) {
/* 1758 */         if ("0".equals(str)) {
/* 1759 */           request.setAttribute(flag + "Y", "&nbsp;零");
/*      */         } else {
/* 1761 */           request.setAttribute(flag + "Y", "&nbsp;" + swtichtoChinese(str.charAt(0)));
/*      */         } 
/*      */       } 
/*      */     } 
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String regexReplaceString(String strIn, String regexString, Object target) {
/* 1776 */     String targetString = filterNull(target);
/* 1777 */     return regexReplaceString(strIn, regexString, targetString);
/*      */   }
/*      */ 
/*      */   
/*      */   public static String regexReplaceString(String strIn, String regexString, String target) {
/* 1782 */     Pattern p = Pattern.compile(regexString, 2);
/* 1783 */     String s = strIn;
/* 1784 */     Matcher m = p.matcher(s);
/*      */     
/* 1786 */     StringBuffer sb = new StringBuffer();
/* 1787 */     int i = 0;
/* 1788 */     boolean result = m.find();
/* 1789 */     while (result) {
/* 1790 */       i++;
/*      */       try {
/* 1792 */         m.appendReplacement(sb, target.replace("$", "\\$"));
/* 1793 */       } catch (Exception e) {
/* 1794 */         e.printStackTrace();
/*      */       } 
/* 1796 */       result = m.find();
/*      */     } 
/* 1798 */     m.appendTail(sb);
/*      */     
/* 1800 */     return sb.toString();
/*      */   }
/*      */   
/*      */   public static String StripHTML(String input) {
/* 1804 */     StringBuffer output = new StringBuffer();
/* 1805 */     StringBuffer temp = new StringBuffer();
/* 1806 */     boolean inHTML = false;
/* 1807 */     for (int i = 0; i < input.length(); i++) {
/* 1808 */       char c = input.charAt(i);
/* 1809 */       if (c == '<') {
/*      */         
/* 1811 */         if (inHTML) {
/* 1812 */           output.append(temp.toString());
/* 1813 */           temp = new StringBuffer();
/*      */         } 
/* 1815 */         inHTML = true;
/* 1816 */         temp.append(c);
/*      */       }
/* 1818 */       else if (c == '>') {
/* 1819 */         inHTML = false;
/* 1820 */         if (temp.toString().length() > 1) {
/* 1821 */           temp = new StringBuffer();
/*      */         } else {
/* 1823 */           output.append(temp.toString());
/* 1824 */           output.append(c);
/* 1825 */           temp = new StringBuffer();
/*      */         }
/*      */       
/* 1828 */       } else if (!inHTML) {
/* 1829 */         output.append(c);
/*      */       } else {
/*      */         
/* 1832 */         temp.append(c);
/*      */       } 
/*      */     } 
/*      */ 
/*      */     
/* 1837 */     output.append(temp.toString());
/* 1838 */     return output.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String StripHTML1(String source) {
/* 1846 */     String result = source.replace("\r", " ");
/*      */     
/* 1848 */     result = result.replace("\n", " ");
/*      */     
/* 1850 */     result = result.replace("\t", "");
/* 1851 */     result = regexReplaceString(result, "( )+", " ");
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */     
/* 1857 */     result = regexReplaceString(result, "<( )*head([^>])*>", "<head>");
/* 1858 */     result = regexReplaceString(result, "(<( )*(/)( )*head( )*>)", "</head>");
/* 1859 */     result = regexReplaceString(result, "(<head>).*(</head>)", "");
/*      */ 
/*      */     
/* 1862 */     result = regexReplaceString(result, "<( )*script([^>])*>", "<script>");
/* 1863 */     result = regexReplaceString(result, "(<( )*(/)( )*script( )*>)", "</script>");
/*      */ 
/*      */     
/* 1866 */     result = regexReplaceString(result, "(<script>).*(</script>)", "");
/*      */ 
/*      */     
/* 1869 */     result = regexReplaceString(result, "<( )*style([^>])*>", "<style>");
/* 1870 */     result = regexReplaceString(result, "(<( )*(/)( )*style( )*>)", "</style>");
/* 1871 */     result = regexReplaceString(result, "(<style>).*(</style>)", "");
/*      */ 
/*      */     
/* 1874 */     result = regexReplaceString(result, "<( )*td([^>])*>", "\t");
/*      */ 
/*      */     
/* 1877 */     result = regexReplaceString(result, "<( )*br( )*>", "\r");
/* 1878 */     result = regexReplaceString(result, "<( )*li( )*>", "\r");
/*      */ 
/*      */ 
/*      */     
/* 1882 */     result = regexReplaceString(result, "<( )*div([^>])*>", "\r\r");
/* 1883 */     result = regexReplaceString(result, "<( )*tr([^>])*>", "\r\r");
/* 1884 */     result = regexReplaceString(result, "<( )*p([^>])*>", "\r\r");
/*      */ 
/*      */ 
/*      */     
/* 1888 */     result = regexReplaceString(result, "<[^>]*>", "");
/*      */ 
/*      */     
/* 1891 */     result = regexReplaceString(result, "&nbsp;", " ");
/*      */     
/* 1893 */     result = regexReplaceString(result, "&bull;", " * ");
/* 1894 */     result = regexReplaceString(result, "&lsaquo;", "<");
/* 1895 */     result = regexReplaceString(result, "&rsaquo;", ">");
/* 1896 */     result = regexReplaceString(result, "&trade;", "(tm)");
/* 1897 */     result = regexReplaceString(result, "&frasl;", "/");
/*      */ 
/*      */     
/* 1900 */     result = regexReplaceString(result, "&copy;", "(c)");
/* 1901 */     result = regexReplaceString(result, "&reg;", "(r)");
/*      */ 
/*      */     
/* 1904 */     result = regexReplaceString(result, "&(.{2,6});", "");
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */     
/* 1910 */     result = result.replace("\n", "\r");
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */     
/* 1916 */     result = regexReplaceString(result, "(\r)( )+(\r)", "\r\r");
/* 1917 */     result = regexReplaceString(result, "(\t)( )+(\t)", "\t\t");
/* 1918 */     result = regexReplaceString(result, "(\t)( )+(\r)", "\t\r");
/* 1919 */     result = regexReplaceString(result, "(\r)( )+(\t)", "\r\t");
/* 1920 */     result = regexReplaceString(result, "(\r)(\t)+(\r)", "\r\r");
/*      */ 
/*      */     
/* 1923 */     result = regexReplaceString(result, "(\r)(\t)+", "\r\t");
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */     
/* 1931 */     String breaks = "\r\r\r";
/*      */     
/* 1933 */     String tabs = "\t\t\t\t\t";
/*      */     
/* 1935 */     for (int index = 0; index < result.length(); index++) {
/* 1936 */       result = result.replace(breaks, "\r\r");
/* 1937 */       result = result.replace(tabs, "\t\t\t\t");
/* 1938 */       breaks = breaks + "\r";
/* 1939 */       tabs = tabs + "\t";
/*      */     } 
/*      */ 
/*      */     
/* 1943 */     return result;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String RtfToString(String rtf) throws Exception {
/* 1958 */     RTFEditorKit rtf_edit = new RTFEditorKit();
/*      */     
/* 1960 */     DefaultStyledDocument doc = new DefaultStyledDocument();
/*      */     
/* 1962 */     StringReader reader = new StringReader(rtf);
/*      */     
/* 1964 */     rtf_edit.read(reader, doc, 0);
/*      */     
/* 1966 */     String text = doc.getText(0, doc.getLength());
/* 1967 */     text = new String(text.getBytes("ISO8859-1"), "GBK");
/* 1968 */     text = text.replaceAll(" ", "&nbsp;");
/* 1969 */     text = text.replaceAll("\\n", "<br>");
/* 1970 */     text = text.replaceAll("\\r", "<br>");
/* 1971 */     return text;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String replaceToHtml(String source) {
/* 1981 */     if (isNullOrBlank(source)) {
/* 1982 */       return "";
/*      */     }
/* 1984 */     return source.replace("\r\n", "<br>").replace("\n", "<br>");
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static int countZH(String str) {
/* 1994 */     int count = 0;
/* 1995 */     String regEx = "[一-龥︰-ﾠ]";
/* 1996 */     Pattern p = Pattern.compile(regEx);
/* 1997 */     Matcher m = p.matcher(str);
/* 1998 */     while (m.find()) {
/* 1999 */       for (int i = 0; i <= m.groupCount(); i++) {
/* 2000 */         count++;
/*      */       }
/*      */     } 
/* 2003 */     return count;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static boolean isExistParam(String str) {
/* 2014 */     if (str == null) {
/* 2015 */       return false;
/*      */     }
/* 2017 */     if (str.contains("[@") && str.contains("@]")) {
/* 2018 */       return true;
/*      */     }
/* 2020 */     return false;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static boolean isExistParam(Map<String, Object> map) {
/* 2030 */     if (map == null) {
/* 2031 */       return false;
/*      */     }
/* 2033 */     Set<String> keySet = map.keySet();
/* 2034 */     for (String element : keySet) {
/* 2035 */       String key = element;
/* 2036 */       String value = (String)map.get(key);
/* 2037 */       if (isExistParam(value)) {
/* 2038 */         return true;
/*      */       }
/*      */     } 
/* 2041 */     return false;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String transSql(String content, Map<?, ?> map, List<Object> params) {
/* 2052 */     Pattern p = Pattern.compile("\\[@\\S[^@]*@\\]", 2);
/* 2053 */     Matcher m = p.matcher(content);
/*      */ 
/*      */ 
/*      */     
/* 2057 */     while (m.find()) {
/* 2058 */       String key = m.group().toLowerCase();
/* 2059 */       String paramKey = key.substring(2, key.length() - 2);
/* 2060 */       content = regexReplaceString(content, "\\[@" + paramKey + "@\\]", "?");
/* 2061 */       params.add(map.get(paramKey));
/*      */     } 
/* 2063 */     return content;
/*      */   }
/*      */ 
/*      */   
/*      */   public static String transSql2(String content, Map<?, ?> map, List<Object> params) {
/* 2068 */     Pattern p = Pattern.compile("\\[@\\S[^@]*@\\]", 2);
/* 2069 */     Matcher m = p.matcher(content);
/*      */ 
/*      */ 
/*      */     
/* 2073 */     while (m.find()) {
/* 2074 */       String key = m.group();
/* 2075 */       String paramKey = key.substring(2, key.length() - 2);
/* 2076 */       content = regexReplaceString(content, "\\[@" + paramKey + "@\\]", "?");
/* 2077 */       params.add(map.get(paramKey));
/*      */     } 
/* 2079 */     return content;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String replaceBlank(String str) {
/* 2089 */     Pattern p = Pattern.compile("\\s*|\t|\r|\n");
/* 2090 */     Matcher m = p.matcher(str);
/* 2091 */     String after = m.replaceAll("");
/* 2092 */     return after;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static List<String> splitStrToList(String str, String regex) {
/* 2105 */     List<String> list = new ArrayList<String>();
/* 2106 */     if (str == null) {
/* 2107 */       return list;
/*      */     }
/* 2109 */     if (regex == null) {
/* 2110 */       regex = ",";
/*      */     }
/* 2112 */     String[] strAry = str.split(regex);
/* 2113 */     for (String element : strAry) {
/* 2114 */       list.add(element);
/*      */     }
/* 2116 */     return list;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static List<String> extractFromSpecStr(String srcStr, String regex, int case_state) {
/* 2131 */     if (StringUtils.isEmpty(srcStr)) {
/* 2132 */       return new ArrayList<String>();
/*      */     }
/* 2134 */     if (StringUtils.isEmpty(regex)) {
/* 2135 */       regex = "\\[@([A-Za-z|_]+)@\\]";
/*      */     }
/*      */     
/* 2138 */     Pattern pattern = Pattern.compile(regex);
/* 2139 */     Matcher matcher = pattern.matcher(srcStr);
/*      */     
/* 2141 */     List<String> extractList = new ArrayList<String>();
/* 2142 */     while (matcher.find()) {
/* 2143 */       switch (case_state) {
/*      */         case 1:
/* 2145 */           extractList.add(matcher.group(1).toUpperCase());
/*      */           continue;
/*      */         case -1:
/* 2148 */           extractList.add(matcher.group(1).toLowerCase());
/*      */           continue;
/*      */       } 
/* 2151 */       extractList.add(matcher.group(1));
/*      */     } 
/*      */ 
/*      */     
/* 2155 */     return extractList;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String full2Half(String full) {
/* 2165 */     char[] c = full.toCharArray();
/* 2166 */     for (int i = 0; i < c.length; i++) {
/* 2167 */       if (c[i] == '　') {
/* 2168 */         c[i] = ' ';
/* 2169 */       } else if (c[i] > '＀' && c[i] < '｟') {
/* 2170 */         c[i] = (char)(c[i] - 65248);
/*      */       } 
/*      */     } 
/* 2173 */     return new String(c);
/*      */   }
/*      */ 
/*      */ 
/*      */   
/*      */   public static String filterSupplementaryChars(String text) {
/* 2179 */     StringBuilder sb = new StringBuilder();
/*      */     
/* 2181 */     if (text == null) {
/* 2182 */       return "";
/*      */     }
/* 2184 */     char[] data = text.toCharArray();
/* 2185 */     for (int i = 0, len = data.length; i < len; i++) {
/*      */       
/* 2187 */       char c = data[i];
/* 2188 */       char high = c;
/*      */       
/* 2190 */       if (!Character.isHighSurrogate(high)) {
/* 2191 */         sb.append(c);
/*      */       }
/*      */       else {
/*      */         
/* 2195 */         if (i + 1 == len) {
/*      */           break;
/*      */         }
/* 2198 */         char low = data[i + 1];
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */         
/* 2204 */         if (Character.isSurrogatePair(high, low)) {
/*      */           
/* 2206 */           int codePoint = Character.toCodePoint(high, low);
/* 2207 */           if (Character.isSupplementaryCodePoint(codePoint))
/*      */           {
/* 2209 */             i++;
/*      */           }
/*      */           else
/*      */           {
/* 2213 */             sb.append(c);
/*      */           }
/*      */         
/*      */         }
/*      */         else {
/*      */           
/* 2219 */           sb.append(c);
/*      */         } 
/*      */       } 
/*      */     } 
/*      */     
/* 2224 */     return sb.toString();
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String XHTMLEnc(String s) {
/* 2238 */     return XMLOrXHTMLEnc(s, "&#39;");
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String XMLOrXHTMLEnc(String s, String aposReplacement) {
/* 2255 */     int ln = s.length();
/*      */     
/* 2257 */     for (int i = 0; i < ln; i++) {
/*      */       
/* 2259 */       char c = s.charAt(i);
/*      */       
/* 2261 */       if (c == '<' || c == '>' || c == '&' || c == '"' || c == '\'') {
/*      */         
/* 2263 */         StringBuffer b = new StringBuffer(s.substring(0, i));
/*      */         
/* 2265 */         switch (c) {
/*      */ 
/*      */           
/*      */           case '<':
/* 2269 */             b.append("&lt;");
/*      */             break;
/*      */ 
/*      */ 
/*      */           
/*      */           case '>':
/* 2275 */             b.append("&gt;");
/*      */             break;
/*      */ 
/*      */ 
/*      */           
/*      */           case '&':
/* 2281 */             b.append("&amp;");
/*      */             break;
/*      */ 
/*      */ 
/*      */           
/*      */           case '"':
/* 2287 */             b.append("&quot;");
/*      */             break;
/*      */ 
/*      */ 
/*      */           
/*      */           case '\'':
/* 2293 */             b.append(aposReplacement);
/*      */             break;
/*      */         } 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */         
/* 2301 */         int next = ++i;
/*      */         
/* 2303 */         while (i < ln) {
/*      */           
/* 2305 */           c = s.charAt(i);
/*      */           
/* 2307 */           if (c == '<' || c == '>' || c == '&' || c == '"' || c == '\'') {
/*      */             
/* 2309 */             b.append(s.substring(next, i));
/*      */             
/* 2311 */             switch (c) {
/*      */ 
/*      */               
/*      */               case '<':
/* 2315 */                 b.append("&lt;");
/*      */                 break;
/*      */ 
/*      */ 
/*      */               
/*      */               case '>':
/* 2321 */                 b.append("&gt;");
/*      */                 break;
/*      */ 
/*      */ 
/*      */               
/*      */               case '&':
/* 2327 */                 b.append("&amp;");
/*      */                 break;
/*      */ 
/*      */ 
/*      */               
/*      */               case '"':
/* 2333 */                 b.append("&quot;");
/*      */                 break;
/*      */ 
/*      */ 
/*      */               
/*      */               case '\'':
/* 2339 */                 b.append(aposReplacement);
/*      */                 break;
/*      */             } 
/*      */ 
/*      */ 
/*      */             
/* 2345 */             next = i + 1;
/*      */           } 
/*      */ 
/*      */           
/* 2349 */           i++;
/*      */         } 
/*      */ 
/*      */         
/* 2353 */         if (next < ln)
/*      */         {
/* 2355 */           b.append(s.substring(next));
/*      */         }
/*      */ 
/*      */         
/* 2359 */         s = b.toString();
/*      */ 
/*      */         
/*      */         break;
/*      */       } 
/*      */     } 
/*      */ 
/*      */     
/* 2367 */     return s;
/*      */   }
/*      */   
/*      */   public static String getIP(HttpServletRequest request) {
/* 2371 */     String ip = request.getHeader("X-Forwarded-For");
/*      */     
/* 2373 */     if (ip == null || ip.length() == 0) {
/* 2374 */       ip = request.getHeader("WL-Proxy-Client-IP");
/*      */     }
/*      */     
/* 2377 */     if (ip == null || ip.length() == 0) {
/* 2378 */       ip = request.getRemoteAddr();
/*      */     }
/*      */     
/* 2381 */     return ip;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String oracleClob2Str(Clob clob) throws Exception {
/* 2395 */     return (clob != null) ? clob.getSubString(1L, (int)clob.length()) : null;
/*      */   }
/*      */   
/*      */   public static void main(String... strings) {
/* 2399 */     String ss = " from org_department t where org_code = [@org_Code@] and dept_name like '%' || [@startwith@] || '%' and dept_code =[@dept_code@] and dept_name like '%' || [@startWith@] || '%'";
/* 2400 */     List<String> keylist = extractFromSpecStr(ss, null, 1);
/*      */     
/* 2402 */     for (String str : keylist) {
/* 2403 */       System.out.println(str);
/*      */     }
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static String str2str(String str, Map<String, Object> param) {
/* 2421 */     Pattern p = Pattern.compile("\\[@\\S[^@]*@\\]", 2);
/* 2422 */     Matcher m = p.matcher(str);
/*      */ 
/*      */ 
/*      */     
/* 2426 */     Map<String, Object> paraMap = new HashMap<String, Object>();
/* 2427 */     paraMap.putAll(param);
/*      */     
/* 2429 */     mapKey2Lowercase(paraMap);
/*      */     
/* 2431 */     while (m.find()) {
/* 2432 */       String key = m.group().toLowerCase();
/* 2433 */       String paramKey = key.substring(2, key.length() - 2);
/* 2434 */       str = regexReplaceString(str, "\\[@" + paramKey + "@\\]", paraMap.get(paramKey));
/*      */     } 
/* 2436 */     return str;
/*      */   }
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */ 
/*      */   
/*      */   public static Map<String, Object> mapKey2Lowercase(Map<String, Object> oldMap) {
/* 2447 */     Map<String, Object> newMap = new HashMap<String, Object>();
/* 2448 */     for (Map.Entry<String, Object> entry : oldMap.entrySet()) {
/* 2449 */       newMap.put(((String)entry.getKey()).toLowerCase(), (entry.getValue() instanceof String) ? entry.getValue().toString().trim() : entry.getValue());
/*      */     }
/*      */     
/* 2452 */     oldMap.clear();
/* 2453 */     oldMap.putAll(newMap);
/* 2454 */     return oldMap;
/*      */   }
/*      */   
/*      */   public static String clob2str(Clob clob) {
/* 2458 */     String reString = "";
/* 2459 */     Reader is = null;
/*      */     try {
/* 2461 */       if (clob != null) {
/* 2462 */         is = clob.getCharacterStream();
/* 2463 */         char[] tempDoc = new char[(int)clob.length()];
/* 2464 */         is.read(tempDoc);
/* 2465 */         reString = new String(tempDoc);
/*      */       } 
/* 2467 */     } catch (Exception e) {
/* 2468 */       e.printStackTrace();
/*      */     } finally {
/* 2470 */       if (is != null)
/*      */         try {
/* 2472 */           is.close();
/* 2473 */         } catch (IOException e) {
/* 2474 */           e.printStackTrace();
/*      */         }  
/*      */     } 
/* 2477 */     return reString;
/*      */   }
/*      */ 
/*      */   
/*      */   public static String replaceNameX(String type, String str) {
/* 2482 */     StringBuffer sb = new StringBuffer();
/* 2483 */     if (StringUtils.equals(type, "name")) {
/*      */       
/* 2485 */       String reg = ".{1}";
/* 2486 */       Pattern p = Pattern.compile(reg);
/* 2487 */       Matcher m = p.matcher(str);
/* 2488 */       int i = 0;
/* 2489 */       while (m.find()) {
/* 2490 */         i++;
/* 2491 */         if (i == 1)
/*      */           continue; 
/* 2493 */         m.appendReplacement(sb, "*");
/*      */       } 
/* 2495 */       m.appendTail(sb);
/* 2496 */       return sb.toString();
/* 2497 */     }  if (StringUtils.equals(type, "mobile")) {
/* 2498 */       str = str.replaceAll("(\\d{3})\\d{8}(\\d{0})", "$1********$2");
/* 2499 */       return str;
/* 2500 */     }  if (StringUtils.equals(type, "idCard")) {
/* 2501 */       str = str.replaceAll("(\\d{3})\\d{12}(\\d{0})", "$1************$2");
/* 2502 */       return str;
/* 2503 */     }  if (StringUtils.equals(type, "email")) {
/*      */       
/* 2505 */       String reg = ".{1}";
/* 2506 */       Pattern p = Pattern.compile(reg);
/* 2507 */       Matcher m = p.matcher(str);
/* 2508 */       int i = 0;
/* 2509 */       while (m.find()) {
/* 2510 */         i++;
/* 2511 */         if (i == 1 || i == str.length() || i == str.length() - 1 || i == str.length() - 2 || i == str.length() - 3)
/*      */           continue; 
/* 2513 */         m.appendReplacement(sb, "*");
/*      */       } 
/* 2515 */       m.appendTail(sb);
/* 2516 */       return sb.toString();
/*      */     } 
/* 2518 */     return null;
/*      */   }
/*      */ }


/* Location:              D:\文件kjt\WEB-INF\lib\egrant-core-2.2.20240205.1659.jar!\com\iris\egran\\utils\IrisStringUtils.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       1.1.3
 */